#include "logreader.h"
#include <QFileInfo>
#include <QMessageBox>
#include <QDebug>
#include "general.h"
#include <QRegularExpression>
#include <QRegularExpressionMatch>
#include "scriptreader.h"
#include <QThread>
#include <QApplication>




LogReader::LogReader(QObject *parent)
    : QObject{parent}
{
    p_text = std::make_unique<QString>("");
    p_textIn = std::make_unique<QTextStream>(p_text.get());

}

LogReader::~LogReader()
{
    qDebug()<<"logreader destructed";
}

// LogReader::LogReader(QString filePath)
// {
//     file = std::make_unique<QFile>(filePath);
//     if (!file->open(QIODevice::ReadWrite)) {
//         QMessageBox::warning(nullptr, u8"错误", u8"无法创建输出文件");
//         return;
//     }
//     m_textIn = std::make_unique<QTextStream>(file.get());

// }



/**
 * 打开文件
 * @param filePath : 文件路径
 * @return : None
 */
// void LogReader::openFile(QString filePath)
// {
//     QFileInfo fi(filePath);
//     if(fi.exists()) {
//         file = std::make_unique<QFile>(filePath);
//         if(!file->open(QFile::ReadWrite)){
//             QMessageBox::warning(Q_NULLPTR, u8"警告", u8"文件"+ filePath + u8"打开失败");
//         }
//         m_textIn = std::make_unique<QTextStream>(file.get());
//     }
// }

void LogReader::addFile(const QString& filePath)
{
    m_fileList.append(filePath);
}


/**
 * 根据json对象获取数据, 列表的每个元素是每个周期各变量的值
 * @param logData : 获取后的数据填入该参数中
 * @param cycleFeatures : 周期特征
 * @param valueArray : 需要获取的值变量名的数组
 * @return : None
 */
void LogReader::getValueFromLog(
    const QString& cycleFeatures,
    const std::shared_ptr<QJsonArray>& valueArray
    )
{
    static QRegularExpression re;
    QHash< QString, QVector< std::shared_ptr<int> > > ret_hash;

    for(auto const &file : std::as_const(m_fileList)) {
        QFile inputFile(file);
        if (!inputFile.open(QIODevice::ReadOnly)) {
            QMessageBox::warning(nullptr, u8"警告", u8"文件打开失败: " + file);
            return;
        }


        QTextStream in(&inputFile);
        *p_textIn << "\n";
        *p_textIn << in.readAll();  // 将输入文件内容写入输出流

        inputFile.close();
        // emit sendCount(index++);
    }

    if(valueArray) {
        int index = 0;
        emit sendTotalVarCount(valueArray->size());
        // qDebug()<<"valueArray size: "<<valueArray->size();
        // 遍历配置文件的变量格式获取每个变量的名称
        for (int i = 0; i < valueArray->size(); i++) {
            QJsonObject t_obj = (*valueArray)[i].toObject();

            QString varFormatStr = t_obj[CONFIG_VAR_FORMAT_KEY].toString();
            re.setPattern(u8R"(\{([^\}]+)\})");
            QRegularExpressionMatchIterator matchs = re.globalMatch(varFormatStr);
            QString valuePattern = varFormatStr;
            // 添加转义字符
            valuePattern = makeRegularString(valuePattern);
            QStringList t_varNameList;
            while(matchs.hasNext()) {
                // 获取{}中的内容
                QRegularExpressionMatch match = matchs.next();
                QString varName = match.captured(1);

                // 将变量名和空列表组成一个hash，加入到返回列表中
                QVector<std::shared_ptr<int>> val_list;
                ret_hash[varName] = val_list;
                // 将格式为“\\{变量名\\}”替换为正则表达式"(\d)"
                valuePattern.replace(u8"\\{" + varName + u8"\\}", u8R"((\d+))");
                t_varNameList.append(varName);
            }
            // if (index == 0) emit sendTotalVarCount(t_varNameList.length());
            re.setPattern(valuePattern);
            // 遍历每个周期，提取每个变量的值
            QString cycleStr;
            // 重新定位文件指针到文件开头
            QString lineFeatureString = t_obj[CONFIG_LINE_FEATURES_KEY].toString();
            while (!(cycleStr = getNextCycle(cycleFeatures)).isEmpty()) {
                // qDebug()<<cycleStr;
                bool flag = false;
                QTextStream ts(&cycleStr);
                while(!ts.atEnd()) {
                    QString lineStr = ts.readLine();
                    if(!lineFeatureString.isEmpty() && !lineStr.contains(lineFeatureString)) continue;
                    QRegularExpressionMatchIterator matchs = re.globalMatch(lineStr);
                    while (matchs.hasNext()) {
                        flag = true;
                        QRegularExpressionMatch match = matchs.next();
                        for (int n = 0; n < match.lastCapturedIndex(); n++) {
                            ret_hash[t_varNameList[n]].append(std::make_shared<int>(match.captured(n + 1).toInt()));
                            // qDebug()<< t_varNameList[n] << match.captured(n + 1).toInt();
                        }
                    }
                }
                // 如果没有找到周期特征，该周期使用空指针
                if(!flag) {
                    for(auto const &tVarName : std::as_const(t_varNameList)){
                        ret_hash[tVarName].append(Q_NULLPTR);
                    }
                }
            }
            emit sendReadVar(++index);
            p_textIn->seek(0);
        }
        // // 确保进度条达到最大值
        // if (index > 0) {
        //     emit sendReadVar(index); // 发送最终进度值
        // }
    }

    // emit readOneFinished();
    emit readFinished(ret_hash);

}




/**
 * 读取文件
 * @param filePath : 文件路径
 * @return : None
 */
QString LogReader::getNextCycle(const QString& cycleFeatures)
{
    QString ret_str;

    if(p_textIn) {
        while(!p_textIn->atEnd()) {
            QString lineStr = p_textIn->readLine();
            if(lineStr.contains(cycleFeatures)) break;
            ret_str += lineStr + "\n";
        }
    }
    return ret_str;
}


